askirmas / react-classnaming

const {keys: $keys} = Object

it("`in string` vs `:string`", () => {

  type In = {[k in string]: boolean}

  type Colon = {[k: string]: boolean}

  function check1(_: {some: boolean}) {}

  function checkR<K extends string>(_: {[k in K]: boolean}) {}

  function checkC(_: {[k: string]: boolean}) {}

  const input1: In = {}, input2: Colon = {}

  //@ts-expect-error

  check1(input1)

  //@ts-expect-error

  check1(input2)

  checkR(input1)

  checkR(input2)

  checkC(input1)

  checkC(input2)

}) 

describe("this", () => {

  type Context = {context: string}

  it.todo("`this?` is illegal")

    const suite1 = thising()

    , suite2 = thising.bind({context: ""})()

    , suite1Check: Record<string, typeof suite1> = {

      "null": null,

      //@ts-expect-error

      "true": true

    }

    , suite2Check: Record<string, typeof suite2> = {

      //TODO #13 @ts-expect-error

      "null": null,

      //@ts-expect-error //TODO #13

      "true": true

    }

    expect({suite1Check, suite2Check}).toBeInstanceOf(Object)

  })

  it("|undefined - NOPE", () => {  

    function thising(this: undefined | Context): typeof this extends Context ? true : null {

      //@ts-expect-error

      return this && 'context' in this

      ? true

      : null

    }

    //@ts-expect-error //TODO #13 The 'this' context of type 'void' is not assignable

    const suite1 = thising()

    , suite2 = thising.bind({context: ""})()

    , suite1Check: Record<string, typeof suite1> = {

      "null": null,

      //@ts-expect-error

      "true": true

    }

    , suite2Check: Record<string, typeof suite2> = {

      //TODO #13 @ts-expect-error

      "null": null,

      //@ts-expect-error //TODO #13

      "true": true

    }

    expect({suite1Check, suite2Check}).toBeInstanceOf(Object)

  })

  it("|unknown - NOPE", () => {  

    function thising(this: unknown | Context): typeof this extends Context ? true : null {

      //@ts-expect-error

      return this && 'context' in this

      ? true

      : null

    }

    const suite1 = thising()

    , suite2 = thising.bind({context: ""})()

    , suite1Check: Record<string, typeof suite1> = {

      "null": null,

      //@ts-expect-error

      "true": true

    }

    , suite2Check: Record<string, typeof suite2> = {

      //TODO #13 @ts-expect-error

      "null": null,

      //@ts-expect-error //TODO #13

      "true": true

    }

    expect({suite1Check, suite2Check}).toBeInstanceOf(Object)

  })

  it("overload", () => {

    function thising(): null

    function thising(this: Context): true 

    function thising(this: void | Context) {

      return this && 'context' in this

      ? true

      : null

    }

    const suite1 = thising()

    , suite2 = thising.bind({context: ""})()

    , suite1Check: Record<string, typeof suite1> = {

      "null": null,

      //@ts-expect-error

      "true": true

    }

    , suite2Check: Record<string, typeof suite2> = {

      //@ts-expect-error

      "null": null,

      "true": true

    }

    expect({suite1Check, suite2Check}).toBeInstanceOf(Object)

  })

  it("throw variable - Nope", () => {

    function _thising(this: void | Context) {

      return this && 'context' in this

      ? true

      : null

    }

    //Same for ((this: Context) => true) | () => null)

    type Thising = (<T>(this: T) => T extends Context ? true : null)

    const thising = _thising as Thising

    const suite1 = thising()

    , binded = thising.bind({context: ""})

    , suite2 = binded()

    , suite1Check: Record<string, typeof suite1> = {

      "null": null,

      //@ts-expect-error

      "true": true

    }

    , suite2Check: Record<string, typeof suite2> = {

      //TODO #13 @ts-expect-error

      "null": null,

      //@ts-expect-error //TODO #13

      "true": true

    }

    expect({suite1Check, suite2Check}).toBeInstanceOf(Object)

  })

  it("idfn this", () => {

    function thising<T>(this: T) {

      return this

    }

    const suite = thising()

    , suiteCheck: Record<string, typeof suite> = {

      "void": undefined

    }

    expect({suiteCheck}).toBeInstanceOf(Object)

  })

})

describe("UX of TS choice", () => {

  type T1 = {

    class1: string,

    class2: undefined

  }

  // it("union", () => {

  //   type tUnion<S extends CssModule> = (

  //     <A extends {[K in keyof S]?: V}>(source: A) => string

  //   ) | (

  //     <A extends {[K in keyof S]?: V}>(inject: string, source: A) => string

  //   );

  //   // const str = <S extends CssModule>(arg1: strS) => $keys(source).join(" ")

  // })

  // it("expression 1", () => {

  //   type tExpression1<S extends CssModule> = (

  //     <A extends {[K in keyof S]?: V}>(arg0: string|A, arg1?: typeof arg0 extends string ? A : never) => string

  //   );  

  // })

  // it("overload interface", () => {

  //   interface iOverload<S extends CssModule> {

  //     <A extends {[K in keyof S]?: V}>(arg0: string): string

  //     <A extends {[K in keyof S]?: V}>(arg0: string, arg1: A): string

  //   }  

  // })

  it("overload function", () => {

    function joiner<S extends CssModule>(source: {[K in keyof S]?: V}) :string

    function joiner<S extends CssModule>(inj: string, source: {[K in keyof S]?: V}) :string

    function joiner<S extends CssModule, F1 extends {[K in keyof S]?: V} | string>(

      arg0: F1,

      // arg1?: typeof arg0 extends string ? {[K in keyof S]?: V} : never 

      arg1?: F1 extends string ? Exclude<F1, string> : never

    ) {

      return `${

        typeof arg0 === "string" ? arg0 : $keys(arg0) 

      } ${

        arg1 === undefined ? "" : $keys(arg1).join(" ")

      }`.trim()

    }

    const bothObjects = joiner<T1>(

      //@ts-expect-error Argument of type '{ class1: string; }' is not assignable to parameter of type 'string'

      {class1: ""},

      {class2: ""}

    )

    , redundantKey = joiner<T1>(

      //@ts-expect-error Argument of type '{ class3: string; }' is not assignable

      {class3: ""}

    )

    expect({bothObjects, redundantKey}).toBeInstanceOf(Object)

  })

})